package com.jk.service;

import com.jk.Util.PayUserCouponConstant;
import com.jk.Util.UUIDUtil;
import com.jk.dao.PayUserCouponDao;
import com.jk.pojo.PayLog;
import com.jk.pojo.PayShopsCoupon;
import com.jk.pojo.PayUser;
import com.jk.pojo.PayUserCoupon;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 用户优惠券实现类层
 * Created by XSJ on 2017/12/19.
 */
@Service("payUserCouponServiceImpl")
public class PayUserCouponServiceImpl implements PayUserCouponService {

    /**
     * 按byType自动注入用户优惠券dao层
     */
    @Autowired
    private PayUserCouponDao payUserCouponDao;



    /**
     * 根据用户的主键id查询此用户共有多少张优惠券
     * @param userid
     * @return
     */
    @Override
    public int queryPayUserCouponCount(String userid) {
        //将查询到的数据返回到controller层
        return payUserCouponDao.queryPayUserCouponCount(userid);
    }

    /**
     *通过用户id来查询出该用户所拥有的所有可用优惠券信息  分页查询
     * @return map 查询出的数据
     */
    public Map<String, Object> queryPayShopsCouponList(String userid,int page,int rows) {
        //设置每页开始条数
        int start = (page-1)*rows;
        //查询总条数
        int total = payUserCouponDao.queryPayShopsCouponCount(userid);
        //通过用户id来查询出该用户所拥有的所有可用优惠券信息  分页查询
        List<Map<String,Object>> list = payUserCouponDao.queryPayShopsCouponList(userid,start,rows);
        //创建一个hashMap 将总条数和查询出的数据存放在map中
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("total",total);
        map.put("list",list);
        //将查询出来的值返回到controller
        return map;
    }

    /**
     * //用户根据优惠券id领取优惠券 在service层进行业务逻辑处理
     * @param couponid
     * @return
     */
    @Override
    public Map<String, Object> insertPayUserCoupon(String couponid,String userid) {
        //首先需要定义一个map集合用来存储领取信息
        Map<String, Object> map = new HashMap<String, Object>();
        //根据优惠券id查询优惠券信息
        PayShopsCoupon payShopsCoupon = payUserCouponDao.queryPayShopsCoupon(couponid);
        //根据优惠券id查询用户是否已经领取过此优惠券
        int payUCCount = payUserCouponDao.queryPayUserCouponCountByCouponId(couponid);
        //判断用户优惠券表中是否已经存在该优惠券  如果存在不能领取并给出相应提示  不存在继续进行下一步
        if(payUCCount == PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
            //判断此优惠券在优惠券表中是否存在 存在继续下一步 不存在给出相应提示信息
            if (payShopsCoupon != null) {
                //判断优惠券领取数量是否大小于发放数量 是则继续下一步,不是这不能领取并给出相应提示信息
                if (payShopsCoupon.getGetcount() < payShopsCoupon.getProvidecount()) {
                    //判断优惠券是否过期 过期则无法领取
                    if (UUIDUtil.getDate().before(payShopsCoupon.getOverduetime()) || UUIDUtil.getDate().equals(payShopsCoupon.getOverduetime())) {
                        //实例化用户优惠券对象
                        PayUserCoupon payUserCoupon = new PayUserCoupon();
                        //用户优惠券id为UUID
                        payUserCoupon.setUcid(UUIDUtil.getUUID());
                        //用户优惠券用户id
                        payUserCoupon.setUserid(userid);
                        //优惠券ID
                        payUserCoupon.setCouponid(payShopsCoupon.getCouponid());
                        //用户优惠券过期时间
                        payUserCoupon.setOverduetime(payShopsCoupon.getOverduetime());
                        //用户优惠券状态,默认是1 为未使用 ,2为已使用
                        payUserCoupon.setStatus(PayUserCouponConstant.PAY_USER_COUPON_START_ALREADY_USED);
                        int flag = payUserCouponDao.insertPayUserCoupon(payUserCoupon);
                        if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                            map.put("message","领取成功");
                            //领取成功后将商家优惠券领取数量加一
                            int flagGetCount = payUserCouponDao.updatePayShopsCouponGetCount(couponid);
                            //判断是否修改成功
                            if(flagGetCount > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                map.put("message","领取成功");
                            }else{
                                map.put("message","领取失败");
                            }
                        }else{
                            map.put("message","领取失败");
                        }
                    } else {
                        map.put("message", "此优惠券已过期,无法领取");
                    }
                } else {
                    map.put("message", "您的手速慢了,此优惠券已经被领取完");
                }
            } else {
                map.put("message", "此优惠券已下架");
            }
        }else{
            map.put("message", "您已领取过此优惠券,不能重复领取");
        }
        return map;
    }

    /**
     * 用户购买商品使用优惠券进行抵扣
     * @param userid 用户id
     * @param ucid 用户优惠券id
     * @param goodsPrice 商品价格
     * @param couponid 优惠券id
     * @return
     */
    @Override
    public Map<String, Object> paymentByPayUserCoupon(String userid, String ucid,String shopid, Double goodsPrice, String couponid,String paymentPwd) {
        //首先需要定义一个map集合用来存储抵扣信息
        Map<String, Object> map = new HashMap<String, Object>();
        //根据用户id查询出用户余额
        PayUser payUser = payUserCouponDao.queryUserUserBalance(userid);
        //根据优惠券id查询优惠券信息
        PayShopsCoupon payShopsCoupon = payUserCouponDao.queryPayShopsCoupon(couponid);
        //查询出用户优惠券状态
        PayUserCoupon payUserCoupon = payUserCouponDao.queryPayUserCouponStatus(ucid);

        int paymentPwds = Integer.parseInt(paymentPwd);
        //判断用户支付密码是否正确
        if(paymentPwds==payUser.getPaymentpwd()){
            //判断用户优惠券是否使用过 已使用则无法再次使用
            if(payUserCoupon.getStatus() != PayUserCouponConstant.PAY_USER_COUPON_START_NOT_USED) {
                //判断优惠券是否过期 过期则无法抵扣
                if (UUIDUtil.getDate().before(payShopsCoupon.getOverduetime()) || UUIDUtil.getDate().equals(payShopsCoupon.getOverduetime())) {
                    //判断优惠券类型是否为满减类型并且为本商家优惠券 是则继续下一步,不是则跳过本次判断
                    if (payShopsCoupon.getCoupontype() == PayUserCouponConstant.PAY_USER_COUPON_FULLREDUCEMONEY && payShopsCoupon.getShopid().equals(shopid)) {
                        //判断是否达到满减金额 是则继续下一步,不是则给出相应提示
                        if (payShopsCoupon.getFullreducemoney() <= goodsPrice) {
                            //运算出商品减去优惠金额后的最后金额
                            Double goodCommodityPrice = goodsPrice - payShopsCoupon.getCouponmoney();
                            //判断用户余额是否大于支付金额 大于则进行下一步
                            if (payUser.getUserbalance() > goodCommodityPrice) {
                                //根据用户id修改用户的余额
                                int flag = payUserCouponDao.updateUserBalance(goodCommodityPrice, userid);
                                //判断是否支付成功
                                if (flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                    map.put("messages", "支付成功");
                                    //支付成功后修改此优惠券的状态为已使用,之后将无法再继续使用
                                    payUserCouponDao.updateUserCouponStauts(ucid);
                                    //计算出应加积分数
                                    int integral = (int) (goodCommodityPrice * 0.1);
                                    //将积分加在用户积分中
                                    int flagIntegral = payUserCouponDao.updateUserIntegral(integral, userid);
                                    //判断是否增加成功
                                    if (flagIntegral > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                        map.put("message", "新增" + integral + "积分");
                                    } else {
                                        map.put("message", "获取积分失败");
                                    }
                                } else {
                                    map.put("message", "支付失败");
                                }
                                //实例化日志表
                                PayLog log = new PayLog();
                                /**赋值交易记录ID*/
                                log.setLogId(UUIDUtil.getUUID());
                                /**日志类型 4 消费*/
                                log.setLogType(PayUserCouponConstant.PAY_USER_COUPON_CONSUMPTION);
                                /**日志内容*/
                                log.setLogInfo("支付宝账号"+payUser.getUseraccount()+", 购买商品, 消费金额为"+goodCommodityPrice+"元");
                                /**存储时间*/
                                log.setSaveTime(UUIDUtil.getDate());
                                /**交易金额*/
                                log.setDealAmont(goodCommodityPrice);
                                /**流水单号*/
                                log.setRunNumber("ZFB-"+UUIDUtil.getDate().getTime()+(int)(Math.random()*10000000));
                                /**操作人ID*/
                                log.setOperatorId(payUser.getUserid());
                                if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                    /**是否成功 1 成功  2 失败 */
                                    log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_SUCCESS);
                                }else {
                                    /**是否成功 1 成功  2 失败 */
                                    log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_ERROR);
                                }
                                /**用户ID*/
                                log.setUserId(payUser.getUserid());
                                /**是否回收 1 为不回收 2 为回收*/
                                log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_RECOVERY_YES);
                                /**对日志进行新增*/
                                int logFlag = payUserCouponDao.insertPayUserCouponLog(log);
                                if(logFlag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                    map.put("messageLog", "支付记录成功");
                                }else{
                                    map.put("messageLog", "支付记录失败");
                                }
                            } else {
                                map.put("message", "余额不足,无法支付");
                            }
                        } else {
                            //运算出还差多少钱才能使用满减优惠券 给出相应提示信息
                            Double money = payShopsCoupon.getFullreducemoney() - goodsPrice;
                            map.put("message", "此商品没有达到满减金额,还差" + money + "元才能使用此优惠券");
                        }
                        //判断此优惠券是否为本店优惠券 是则进行下一步 不是则跳出该判断
                    } else if (payShopsCoupon.getShopid().equals(shopid)) {
                        //运算出商品减去优惠金额后的最后金额
                        Double goodCommodityPrice = goodsPrice - payShopsCoupon.getCouponmoney();
                        //判断用户余额是否大于支付金额 大于则进行下一步
                        if (payUser.getUserbalance() > goodCommodityPrice) {
                            //根据用户id修改用户的余额
                            int flag = payUserCouponDao.updateUserBalance(goodCommodityPrice, userid);
                            //判断是否支付成功
                            if (flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                map.put("messages", "支付成功");
                                //支付成功后修改此优惠券的状态为已使用,之后将无法再继续使用
                                payUserCouponDao.updateUserCouponStauts(ucid);
                                int integral = (int) (goodCommodityPrice * 0.1);
                                int flagIntegral = payUserCouponDao.updateUserIntegral(integral, userid);
                                if (flagIntegral > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                    map.put("message", "新增" + integral + "积分");
                                } else {
                                    map.put("message", "获取积分失败");
                                }
                            } else {
                                map.put("message", "支付失败");
                            }
                            //实例化日志表
                            PayLog log = new PayLog();
                            /**赋值交易记录ID*/
                            log.setLogId(UUIDUtil.getUUID());
                            /**日志类型 4 消费*/
                            log.setLogType(PayUserCouponConstant.PAY_USER_COUPON_CONSUMPTION);
                            /**日志内容*/
                            log.setLogInfo("支付宝账号"+payUser.getUseraccount()+", 购买商品, 消费金额为"+goodCommodityPrice+"元");
                            /**存储时间*/
                            log.setSaveTime(UUIDUtil.getDate());
                            /**交易金额*/
                            log.setDealAmont(goodCommodityPrice);
                            /**流水单号*/
                            log.setRunNumber("ZFB-"+UUIDUtil.getDate().getTime()+(int)(Math.random()*10000000));
                            /**操作人ID*/
                            log.setOperatorId(payUser.getUserid());
                            if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                /**是否成功 1 成功  2 失败 */
                                log.setLogSuccess(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_SUCCESS);
                            }else {
                                /**是否成功 1 成功  2 失败 */
                                log.setLogSuccess(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_ERROR);
                            }
                            /**用户ID*/
                            log.setUserId(payUser.getUserid());
                            /**是否回收 1 为不回收 2 为回收*/
                            log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_RECOVERY_YES);
                            /**对日志进行新增*/
                            int logFlag = payUserCouponDao.insertPayUserCouponLog(log);
                            if(logFlag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                map.put("messageLog", "支付记录成功");
                            }else{
                                map.put("messageLog", "支付记录失败");
                            }
                        } else {
                            map.put("message", "余额不足,无法支付");
                        }
                        //判断优惠券类型是否为全场通用优惠券 是则进行下一步 不是则跳出该判断
                    } else if (payShopsCoupon.getCoupontype() == PayUserCouponConstant.PAY_USER_COUPON_CURRENCY) {
                        //运算出商品减去优惠金额后的最后金额
                        Double goodCommodityPrice = goodsPrice - payShopsCoupon.getCouponmoney();
                        //判断用户余额是否大于支付金额 大于则进行下一步
                        if (payUser.getUserbalance() > goodCommodityPrice) {
                            //根据用户id修改用户的余额
                            int flag = payUserCouponDao.updateUserBalance(goodCommodityPrice, userid);
                            //判断是否支付成功
                            if (flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                map.put("messages", "支付成功");
                                //支付成功后修改此优惠券的状态为已使用,之后将无法再继续使用
                                payUserCouponDao.updateUserCouponStauts(ucid);
                                int integral = (int) (goodCommodityPrice * 0.1);
                                int flagIntegral = payUserCouponDao.updateUserIntegral(integral, userid);
                                if (flagIntegral > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                                    map.put("message", "新增" + integral + "积分");
                                } else {
                                    map.put("message", "获取积分失败");
                                }
                            } else {
                                map.put("message", "支付失败");
                            }
                            //实例化日志表
                            PayLog log = new PayLog();
                            /**赋值交易记录ID*/
                            log.setLogId(UUIDUtil.getUUID());
                            /**日志类型 4 消费*/
                            log.setLogType(PayUserCouponConstant.PAY_USER_COUPON_CONSUMPTION);
                            /**日志内容*/
                            log.setLogInfo("支付宝账号"+payUser.getUseraccount()+", 购买商品, 消费金额为"+goodCommodityPrice+"元");
                            /**存储时间*/
                            log.setSaveTime(UUIDUtil.getDate());
                            /**交易金额*/
                            log.setDealAmont(goodCommodityPrice);
                            /**流水单号*/
                            log.setRunNumber("ZFB-"+UUIDUtil.getDate().getTime()+(int)(Math.random()*10000000));
                            /**操作人ID*/
                            log.setOperatorId(payUser.getUserid());
                            if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                /**是否成功 1 成功  2 失败 */
                                log.setLogSuccess(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_SUCCESS);
                            }else {
                                /**是否成功 1 成功  2 失败 */
                                log.setLogSuccess(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_ERROR);
                            }
                            /**用户ID*/
                            log.setUserId(payUser.getUserid());
                            /**是否回收 1 为不回收 2 为回收*/
                            log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_RECOVERY_YES);
                            /**对日志进行新增*/
                            int logFlag = payUserCouponDao.insertPayUserCouponLog(log);
                            if(logFlag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                                map.put("messageLog", "支付记录成功");
                            }else{
                                map.put("messageLog", "支付记录失败");
                            }
                        } else {
                            map.put("message", "余额不足,无法支付");
                        }
                    } else {
                        map.put("message", "此优惠券不符合使用规则,无法使用");
                    }
                } else {
                    map.put("message", "此优惠券已过期,无法使用");
                }
            }else{
                map.put("message", "此优惠券已使用过,无法再次使用");
            }
        }else{
            map.put("message", "支付密码错误,请重新输入");
        }

        return map;
    }

    /**
     *设置定时器执行时间 每隔一段时间去查询用户优惠券表中对的优惠券信息
     *如果过期时间小于当前时间就修改其状态使其优惠券删除
     */
    @Scheduled(cron = "0 0 12 * * ?")
    public void timer(){
        //查询用户优惠券中的优惠券过期时间和主键ID
        List<PayUserCoupon> overdueTime = payUserCouponDao.queryPayUserCouponOverdueTime();
        //遍历循环查询出的list集合中的数据
        for (PayUserCoupon payUserCoupon : overdueTime) {
            //将查询出的过期时间和当前时间进行比较,如果已经过期就执行下一步
            if(UUIDUtil.getDate().after(payUserCoupon.getOverduetime()) || UUIDUtil.getDate().equals(payUserCoupon.getOverduetime())){
                //如果优惠券已经过期就删除该优惠券信息
                payUserCouponDao.deletePayUserCouponStart(payUserCoupon.getUcid());
            }
        }
        //查询出商家优惠券表中的优惠券过期时间和主键ID
        List<PayShopsCoupon> ShopsOverdueTime = payUserCouponDao.queryPayShopsCouponStartOverdueTime();
        //遍历循环查询出的list集合中的数据
        for (PayShopsCoupon payShopsCoupon : ShopsOverdueTime) {
            //将查询出的过期时间和当前时间进行比较,如果已经过期就执行下一步
            if(UUIDUtil.getDate().after(payShopsCoupon.getOverduetime()) || UUIDUtil.getDate().equals(payShopsCoupon.getOverduetime())){
                //如果优惠券已经过期就删除该优惠券信息
                payUserCouponDao.deletePayShopsCouponStart(payShopsCoupon.getCouponid());
            }
        }
    }

    /**
     * 添加商家优惠券
     * @param payShopsCoupon
     * @return
     */
    @Override
    public Map<String, Object> insertPayShopsCoupon(PayShopsCoupon payShopsCoupon,String shopId) {
        Map<String, Object> map = new HashMap<String,Object>();
        //添加主键id UUID
        payShopsCoupon.setCouponid(UUIDUtil.getUUID());
        //添加商家id
        payShopsCoupon.setShopid(shopId);
        //新创建的商品优惠券默认领取数量是 0
        payShopsCoupon.setGetcount(PayUserCouponConstant.PAY_USER_COUPON_FLAG);
        //添加商家优惠券
        int flag = payUserCouponDao.insertPayShopsCoupon(payShopsCoupon);
        //判断是否添加成功
        if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
            map.put("message","添加成功");
        }else{
            map.put("message","添加失败");
        }
        return map;
    }

    /**
     * 查询商家优惠券数据
     * @return
     */
    @Override
    public List<Map<String, Object>> queryShopsCouponListAll() {
        List<Map<String, Object>> list = payUserCouponDao.queryShopsCouponListAll();
        return list;
    }

    /**
     *
     * @param coid
     * @return
     */
    @Override
    public List<Map<String,Object>> queryPayShopsUserCoupon(String coid) {
        List<Map<String,Object>> list = payUserCouponDao.queryPayShopsUserCoupon(coid);
        return list;
    }

    @Override
    public Map<String, Object> paymentByPayUser(String userid, Double goodsPrice, String paymentPwd) {
        //首先需要定义一个map集合用来存储抵扣信息
        Map<String, Object> map = new HashMap<String, Object>();
        //根据用户id查询出用户余额
        PayUser payUser = payUserCouponDao.queryUserUserBalance(userid);
        int paymentPwds = Integer.parseInt(paymentPwd);
        //判断用户支付密码是否正确
        if(paymentPwds==payUser.getPaymentpwd()){
            //判断用户余额是否大于支付金额 大于则进行下一步
            if (payUser.getUserbalance() > goodsPrice) {
                //根据用户id修改用户的余额
                int flag = payUserCouponDao.updateUserBalance(goodsPrice, userid);
                //判断是否支付成功
                if (flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                    map.put("messages", "支付成功");
                    //计算出应加积分数
                    int integral = (int) (goodsPrice * 0.1);
                    //将积分加在用户积分中
                    int flagIntegral = payUserCouponDao.updateUserIntegral(integral, userid);
                    //判断是否增加成功
                    if (flagIntegral > PayUserCouponConstant.PAY_USER_COUPON_FLAG) {
                        map.put("message", "新增" + integral + "积分");
                    } else {
                        map.put("message", "获取积分失败");
                    }
                } else {
                    map.put("message", "支付失败");
                }
                //实例化日志表
                PayLog log = new PayLog();
                /**赋值交易记录ID*/
                log.setLogId(UUIDUtil.getUUID());
                /**日志类型 4 消费*/
                log.setLogType(PayUserCouponConstant.PAY_USER_COUPON_CONSUMPTION);
                /**日志内容*/
                log.setLogInfo("支付宝账号"+payUser.getUseraccount()+", 购买商品, 消费金额为"+goodsPrice+"元");
                /**存储时间*/
                log.setSaveTime(UUIDUtil.getDate());
                /**交易金额*/
                log.setDealAmont(goodsPrice);
                /**流水单号*/
                log.setRunNumber("ZFB-"+UUIDUtil.getDate().getTime()+(int)(Math.random()*10000000));
                /**操作人ID*/
                log.setOperatorId(payUser.getUserid());
                if(flag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                    /**是否成功 1 成功  2 失败 */
                    log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_SUCCESS);
                }else {
                    /**是否成功 1 成功  2 失败 */
                    log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_PAYMENT_ERROR);
                }
                /**用户ID*/
                log.setUserId(payUser.getUserid());
                /**是否回收 1 为不回收 2 为回收*/
                log.setLogStatus(PayUserCouponConstant.PAY_USER_COUPON_RECOVERY_YES);
                /**对日志进行新增*/
                int logFlag = payUserCouponDao.insertPayUserCouponLog(log);
                if(logFlag > PayUserCouponConstant.PAY_USER_COUPON_FLAG){
                    map.put("messageLog", "支付记录成功");
                }else{
                    map.put("messageLog", "支付记录失败");
                }
            } else {
                map.put("message", "余额不足,无法支付");
            }
        }else{
            map.put("message", "支付密码错误,请重新输入");
        }
        return map;
    }
}
